home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / xhearts / client.c next >
Encoding:
C/C++ Source or Header  |  1995-05-09  |  22.7 KB  |  1,007 lines
  1. /*
  2.  * hearts - human interface to hearts program
  3.  *
  4.  * All smarts are in heartsd, which is invoked by initial caller of hearts.
  5.  *
  6.  * Private messages, last-play, auto-play added by:
  7.  *      Mike Yang of Silicon Graphics (mikey@sgi.com)
  8.  *
  9.  * By Bob Ankeney or Generic Computer Products
  10.  * Bug reports to:
  11.  * ...!tektronix!reed!bob
  12.  *
  13.  *
  14.  * Commands to hearts client (r = rank, s = suit):
  15.  *
  16.  * Ars        Add card to hand.
  17.  * Rrs        Remove card from hand.
  18.  * En        Erase window n.
  19.  * G        Get a card.
  20.  * Pnrs<name>    Play card from player n, whose name is <name>.
  21.  * Snpptt<name>    Score points (pp) and total points (tt) for player n.
  22.  * Mn<text>    Message <text> is placed in window n.
  23.  * X        Go away.
  24.  *
  25.  * Messages from client:
  26.  *
  27.  * Prs        Pass/Play card from hand.
  28.  * M<text>        Send message <text> to all players.
  29.  *
  30.  */
  31.  
  32. #include <curses.h>
  33. #include <stdlib.h>
  34. #include <sys/errno.h>
  35. #include "misc.h"
  36. #include "defs.h"
  37. #include "local.h"
  38. #include "client.h"
  39. #ifdef SYSV
  40. #include <sys/termio.h>
  41. #endif
  42.  
  43. typedef struct node *ptr;
  44.  
  45. struct node {
  46.     ptr    llink, rlink;
  47.     int    rank;
  48. };
  49.  
  50. struct    suit_list {
  51.     ptr    head, tail;
  52.     int    length;
  53. } 
  54. my_hand[MAX_SUIT + 1];
  55.  
  56. WINDOW    *card_window[MAX_SUIT + 1],
  57.     *round_window, *lead_window, *inp_window, *text_window,
  58.     *play_window, *tplay_window, *mesg_window, *tmesg_window,
  59.     *header_window, *score_window, *opening_window,
  60.       *play_save,
  61.     **window_ptr[MESG_WINDOW + 1];
  62.  
  63. int    mesg_bottom,    /* Bottom line of lower message window */
  64.     tmesg_bottom;    /* Bottom line of upper message window */
  65. char    show_play,    /* TRUE = show play/score window, FALSE = show mesg */
  66.     show_old;
  67.  
  68. char got_char;
  69.  
  70. mikey_save_swap()
  71. {
  72.   WINDOW *temp;
  73.  
  74.   temp = play_window;
  75.   play_window = play_save;
  76.   play_save = temp;
  77.   touchwin(play_window);
  78. }
  79.  
  80. mikey_old(ref)
  81. int ref;
  82. {
  83.   mikey_save_swap();
  84.   if (ref)
  85.     wrefresh(play_window);
  86.   show_old = !show_old;
  87. }
  88.  
  89. init_suit(list)
  90. struct suit_list *list;
  91. {
  92.     list->length = 0;
  93.     list->head = (ptr) malloc(sizeof(struct node));
  94.     list->tail = (ptr) malloc(sizeof(struct node));
  95.     list->head->llink = NULL; 
  96.     list->tail->rlink = NULL;
  97.     list->head->rlink = list->tail; 
  98.     list->tail->llink = list->head;
  99.     list->head->rank = MAX_RANK + 1; 
  100.     list->tail->rank = 0;
  101. }
  102.  
  103. init(argc_p, argv)
  104. int *argc_p;
  105. char **argv;
  106. {
  107.     int    wimp_out();
  108.     int    suit;
  109.     char    ch;
  110.     char    buffer[128];
  111.     char    *pager;
  112.  
  113.     initscr();
  114.     clearok(stdscr, FALSE);
  115.     crmode();
  116.     init_windows();
  117.  
  118.     mvwaddstr(opening_window, 0, 0, 
  119.           "      ***************************************     ");
  120.     mvwaddstr(opening_window, 1, 0, 
  121.           "      ***  Welcome to the Game of Hearts  ***     ");
  122.     mvwaddstr(opening_window, 2, 0, 
  123.           "      ***************************************     ");
  124.     if (MIKEYJ)
  125.       mvwaddstr(opening_window, 4, 0,
  126.           "     Note that the Jack of Diamonds scores -10    ");
  127.     mvwaddstr(opening_window, 6, 0,
  128.           "Typing 'L' shows the contents of the previous hand");
  129.     mvwaddstr(opening_window, 8, 0,
  130.           "  This version (supposedly) has improved strategy ");
  131.     mvwaddstr(opening_window, 9, 0,
  132.           "      for the computer players.  Send computer    ");
  133.     mvwaddstr(opening_window, 10, 0,
  134.           "         mistakes and suggestions to mikey.       ");
  135.     mvwaddstr(opening_window, 12, 0,
  136.           "            Do you need instructions? ");
  137.     wrefresh(opening_window);
  138.     ch = get_char();
  139.     if ((ch == 'y') || (ch == 'Y')) {
  140.         clear();
  141.         refresh();
  142.         (void) fflush(stdout);
  143.         endwin();
  144.         if (!(pager = getenv ("PAGER")))
  145.             pager = "more";
  146.         (void) sprintf (buffer, "%s %s/%s", pager, HEARTSLIB, INSTRUCT);
  147.         (void) system(buffer);
  148.         crmode();
  149.         printf ("Press return to continue: "); 
  150.         (void) fflush (stdout);
  151.         (void) get_char();
  152.     }
  153.     noecho();
  154.  
  155.     for (suit = CLUBS; suit <= SPADES; suit++)
  156.         init_suit(&my_hand[suit]);
  157. }
  158.  
  159. /*
  160.  *            Screen window layout
  161.  *
  162.  *                   2             4             6             7
  163.  *     0             0             0             0             9
  164.  *      --------------------------------------------------------
  165.  *   0 |             |             |             |             |
  166.  *   1 | card_window | card_window | card_window | card_window |
  167.  *   2 |   [CLUBS]   |  [DIAMONDS] |   [HEARTS]  |   [SPADES]  |
  168.  *     ~             ~             ~             ~             ~
  169.  *     ~             ~             ~             ~             ~
  170.  *  16 |             |             |             |             |
  171.  *     |-------------------------------------------------------|
  172.  *     |                                                       |
  173.  *                         if show_play:
  174.  *
  175.  *                    2                      5                 7
  176.  *     0              2                      8                 9
  177.  *     |                                                       |
  178.  *     ---------------------------------------------------------
  179.  *  17 | round_window |                      |score_text_window|
  180.  *     |--------------|                      |-----------------|
  181.  *  18 |              |                      |                 |
  182.  *     |--------------|                      |                 |
  183.  *  19 | lead_window  |                      |                 |
  184.  *     |--------------|                      |                 |
  185.  *  20 | inp_window   |    play_window       |                 |
  186.  *     |--------------|                      |                 |
  187.  *  21 |              |                      |                 |
  188.  *     |--------------|                      |                 |
  189.  *  22 | text_window  |                      |                 |
  190.  *     |--------------|----------------------------------------|
  191.  *  23 |              |                                        |
  192.  *     ~              ~                 mesg_window            ~
  193.  *     ~              ~                                        ~
  194.  *LINES|              |                                        |
  195.  *     ---------------------------------------------------------
  196.  *
  197.  *                         if !show_play:
  198.  *
  199.  *                    2                      5                 7
  200.  *     0              2                      8                 9
  201.  *     |                                                       |
  202.  *     ---------------------------------------------------------
  203.  *  17 | round_window |     tplay_window     |                 |
  204.  *     |--------------|----------------------------------------|
  205.  *  18 |              |                                        |
  206.  *     |--------------|                                        |
  207.  *  19 | lead_window  |                                        |
  208.  *     |--------------|                                        |
  209.  *  20 | inp_window   |                tmesg_window            |
  210.  *     |--------------|                                        |
  211.  *  21 |              |                                        |
  212.  *     |--------------|                                        |
  213.  *  22 | text_window  |                                        |
  214.  *     |--------------|----------------------------------------|
  215.  *  23 |              |                                        |
  216.  *     ~              ~                 mesg_window            ~
  217.  *     ~              ~                                        ~
  218.  *LINES|              |                                        |
  219.  *     ---------------------------------------------------------
  220.  */
  221. init_windows()
  222. {
  223.     int i;
  224.  
  225.     for (i = CLUBS; i <= SPADES; i++) {
  226.         card_window[i] = newwin(17, 20, 0, (i - 1) * 20);
  227.         leaveok(card_window[i], TRUE);
  228.         werase(card_window[i]);
  229.     }
  230.     round_window    = newwin(1, 22, 17,  0);
  231.     lead_window    = newwin(1, 22, 19,  0);
  232.     inp_window    = newwin(1, 22, 20,  0);
  233.     text_window    = newwin(1, 22, 22,  0);
  234.     play_window    = newwin(6, 35, 17, 23);
  235.     tplay_window    = newwin(1, 57, 17, 23);
  236.     header_window    = newwin(1, 22, 17, 58);
  237.     score_window    = newwin(5, 22, 18, 58);
  238.     mesg_window    = newwin(0, 57, 23, 23);
  239.     tmesg_window    = newwin(5, 57, 18, 23);
  240.     opening_window    = newwin(14,50,  5, 15);
  241.     play_save    = newwin(6, 35, 17, 23);
  242.     mesg_bottom = LINES - 24;
  243.     tmesg_bottom = 4;
  244.     scrollok(mesg_window, TRUE);
  245.     scrollok(tmesg_window, TRUE);
  246.     window_ptr[ROUND_WINDOW] = &round_window;
  247.     window_ptr[LEAD_WINDOW]  = &lead_window;
  248.     window_ptr[INP_WINDOW]   = &inp_window;
  249.     window_ptr[TEXT_WINDOW]  = &text_window;
  250.     window_ptr[PLAY_WINDOW]  = &play_window;
  251.     window_ptr[SCORE_WINDOW] = &score_window;
  252.     window_ptr[MESG_WINDOW]  = &mesg_window;
  253. }
  254.  
  255. /*
  256.  * toggle_mesg - toggle whether showing message window or score/play windows
  257.  */
  258. toggle_mesg()
  259. {
  260.     if (show_play) {
  261.         touchwin(tplay_window);
  262.         touchwin(tmesg_window);
  263.         wrefresh(tplay_window);
  264.         wrefresh(tmesg_window);
  265.     }
  266.     else {
  267.         touchwin(play_window);
  268.         touchwin(header_window);
  269.         touchwin(score_window);
  270.         wrefresh(play_window);
  271.         wrefresh(header_window);
  272.         wrefresh(score_window);
  273.     }
  274.     show_play = !show_play;
  275. }
  276.  
  277. /*
  278.  * ovl_refresh - refresh window only if visible
  279.  */
  280. ovl_refresh(window_num)
  281. int    window_num;
  282. {
  283.     switch (window_num) {
  284.     case PLAY_WINDOW:
  285.         if (show_play)
  286.             wrefresh(play_window);
  287.         break;
  288.     case SCORE_WINDOW:
  289.         if (show_play)
  290.             wrefresh(score_window);
  291.         break;
  292.     default:
  293.         wrefresh(*window_ptr[window_num]);
  294.     }
  295. }
  296.  
  297. /*
  298.  * scroll_mesg - scroll mesg_window onto tmesg_window
  299.  */
  300. scroll_mesg()
  301. {
  302.     int    i;
  303.     char    ch;
  304.     int     x,y;
  305.  
  306. /*
  307.     wmove(tmesg_window, tmesg_bottom, 56);
  308.     scroll(tmesg_window);
  309. */
  310.  
  311.     for (x = 0; x < tmesg_bottom; x++) {
  312.       for (y = 0; y < 56; y++) {
  313.         wmove(tmesg_window,x+1,y);
  314.         ch = winch(tmesg_window);
  315.         wmove(tmesg_window,x,y);
  316.         waddch(tmesg_window, ch);
  317.       }
  318.     }
  319.  
  320.     wmove(tmesg_window, tmesg_bottom, 0);
  321.  
  322.     for (i = 0; i < 56; i++) {
  323.         wmove(mesg_window, 0, i);
  324.         ch = winch(mesg_window);
  325.         waddch(tmesg_window, ch);
  326.     }
  327.     scroll(mesg_window);
  328.     if (!show_play)
  329.         wrefresh(tmesg_window);
  330. }
  331.     
  332. put_card(window, y, x, rank, suit)
  333. WINDOW    *window;
  334. int    y, x,
  335. rank, suit;
  336. {
  337.     mvwaddstr(window, y,     x, "+-----+");
  338.     mvwaddstr(window, y + 1, x, "|     |");
  339.     mvwaddstr(window, y + 2, x, "|     |");
  340.     mvwaddstr(window, y + 3, x, "|     |");
  341.     mvwaddstr(window, y + 4, x, "+-----+");
  342.     if ((suit == HEARTS) || (suit == DIAMONDS))
  343.         wstandout(window);
  344.     mvwaddch(window, y + 1, x + 1, rnames[rank]);
  345.     waddch(window, *snames[suit]);
  346.     mvwaddch(window, y + 3, x + 4, rnames[rank]);
  347.     waddch(window, *snames[suit]);
  348.     wstandend(window);
  349. }
  350.  
  351. print_cards(suit)
  352. int    suit;
  353. {
  354.     int y, x;
  355.     ptr p;
  356.  
  357.     werase(card_window[suit]);
  358.     x = y = 0;
  359.     p = my_hand[suit].head->rlink;
  360.     while (p->rank) {
  361.         if (x == 7) {
  362.             ++x;
  363.             y = 0;
  364.         }
  365.         put_card(card_window[suit], y, x++, p->rank, suit);
  366.         y += 2;
  367.         p = p->rlink;
  368.     }
  369.     wrefresh(card_window[suit]);
  370. }
  371.  
  372. get_char()
  373. {
  374.     char    ch;
  375.  
  376.     if (read(0, &ch, 1) == -1) {
  377.         perror("read");
  378.         abort();
  379.     }
  380.     return(ch);
  381. }
  382.  
  383. read_char()
  384. {
  385.     char    ch;
  386.  
  387.     while (!got_char)
  388.         scan();
  389.     ch = got_char;
  390.     got_char = FALSE;
  391.     return(ch);
  392. }
  393.  
  394. read_card()
  395. {
  396.     int    rank, suit;
  397.     char    buf[64];
  398.  
  399.     do {
  400.         do {
  401.             werase(inp_window);
  402.             wrefresh(inp_window);
  403.             buf[0] = 'P';
  404.             buf[1] = read_char();    /* Get rank (not smelly) */
  405.             if (buf[1] >= 'a')
  406.                 buf[1] += 'A' - 'a';
  407.             if ((buf[1] != '?') && (!(rank = get_rank(buf[1])))) {
  408.                 werase(text_window);
  409.                 waddstr(text_window, "Bad rank!");
  410.                 wrefresh(text_window);
  411.             }
  412.             if (buf[1] == '?')
  413.               rank = 1;
  414.         } 
  415.         while (!rank);
  416.         werase(text_window);
  417.         wrefresh(text_window);
  418.         wprintw(inp_window, "%c ", buf[1]);
  419.         wrefresh(inp_window);
  420.         if (show_old)
  421.           mikey_old(TRUE);
  422.         if (buf[1] == '?')
  423.           suit = HEARTS;
  424.         else {
  425.         buf[2] = read_char();        /* Get suit (not tuxedo) */
  426.         if ((buf[2] >= 'A') && (buf[2] <= 'Z'))
  427.             buf[2] += 'a' - 'A';
  428.         if (!(suit = get_suit(buf[2])) &&
  429. #ifndef SYSV
  430.             (buf[2] != _tty.sg_erase) && (buf[2] != _tty.sg_kill)) {
  431. #else
  432.             (buf[2] != CERASE) && (buf[2] != CKILL)) {
  433. #endif
  434.             werase(text_window);
  435.             waddstr(text_window, "Bad suit!");
  436.             wrefresh(text_window);
  437.         }
  438.           }
  439.     } 
  440.     while (!suit);
  441.     if (buf[1] != '?')
  442.       wprintw(inp_window, "of %s", snames[suit]);
  443.     wrefresh(inp_window);
  444.     if (buf[1] == '?')
  445.       send_auto();
  446.     else
  447.       send_card(buf[1], buf[2]);
  448. }
  449.  
  450. enter_card0(rank, suit)
  451. int    rank, suit;
  452. {
  453.     ptr p, p1;
  454.  
  455.     p = my_hand[suit].head;
  456.     ++my_hand[suit].length;
  457.     while (p->rank > rank)
  458.         p = p->rlink;
  459.     p1 = (ptr) malloc(sizeof(struct node));
  460.     p1->llink = p->llink;
  461.     p1->llink->rlink = p1;
  462.     p->llink = p1;
  463.     p1->rlink = p;
  464.     p1->rank = rank;
  465. }
  466.  
  467. remove_node(p)
  468. ptr    p;
  469.  
  470. {
  471.     p->llink->rlink = p->rlink;
  472.     p->rlink->llink = p->llink;
  473.     free((char *) p);
  474. }
  475.  
  476.  
  477. ptr
  478. find_card(rank_to_play, suit_to_play)
  479. int    rank_to_play, suit_to_play;
  480. {
  481.     ptr    card_to_play;
  482.  
  483.     card_to_play = my_hand[suit_to_play].head->rlink;
  484.     while (card_to_play->rank != rank_to_play)
  485.         card_to_play = card_to_play->rlink;
  486. /*
  487.     remove_node(card_to_play);
  488. */
  489.     --my_hand[suit_to_play].length;
  490.     return(card_to_play);
  491. }
  492.  
  493. enter_card(rank, suit)
  494. int rank, suit;
  495. {
  496.   enter_card0(rank, suit);
  497.   print_cards(suit);
  498. }
  499.  
  500. remove_card(rank, suit)
  501. int rank, suit;
  502. {
  503.   remove_node(find_card(rank, suit));
  504.   print_cards(suit);
  505. }
  506.  
  507. erase_window(window_num)
  508. int window_num;
  509. {
  510.   if (window_num == PLAY_WINDOW) {
  511.     if (show_old)
  512.       mikey_old(TRUE);
  513.     mikey_save_swap();
  514.     werase(tplay_window);
  515.     if (!show_play)
  516.       wrefresh(tplay_window);
  517.   }
  518.   werase(*window_ptr[window_num]);
  519.   ovl_refresh(window_num);
  520. }
  521.  
  522. play_card(player, rch, sch, msg)
  523. int player, rch, sch;
  524. char *msg;
  525. {
  526.   /*
  527.    * Update standard play window
  528.    */
  529.   if (show_old) {
  530.     mikey_old(FALSE);
  531.     put_card(play_window, 0, (player - 1) * 9,
  532.          get_rank(rch), get_suit(sch));
  533.     if (*msg != '\0')
  534.       mvwaddstr(play_window, 5, (player - 1) * 9, msg);
  535.     mikey_old(FALSE);
  536.   } else {
  537.     put_card(play_window, 0, (player - 1) * 9,
  538.          get_rank(rch), get_suit(sch));
  539.     if (*msg != '\0')
  540.       mvwaddstr(play_window, 5, (player - 1) * 9, msg);
  541.   }
  542.   /*
  543.    * Update alternate play window
  544.    */
  545.   if ((sch == 'h') || (sch == 'd'))
  546.     wstandout(tplay_window);
  547.   mvwaddch(tplay_window, 0, (player - 1) * 9, rch);
  548.   waddch(tplay_window, sch);
  549.   wstandend(tplay_window);
  550.   if (show_play)
  551.     wrefresh(play_window);
  552.   else
  553.     wrefresh(tplay_window);
  554.   sleep(1);
  555. }
  556.  
  557. score_points(player, pts, total_pts, msg)
  558. int player, pts, total_pts;
  559. char *msg;
  560. {
  561.   mvwaddstr(score_window, player - 1, 1, "        ");
  562.   mvwaddstr(score_window, player - 1, 1, msg);
  563.   mvwprintw(score_window, player - 1, 9, "% 3d    % 3d",
  564.         pts, total_pts);
  565.   
  566.   ovl_refresh(SCORE_WINDOW);
  567. }
  568.  
  569. display_message(window_num, msg)
  570. int window_num;
  571. char *msg;
  572. {
  573.   int    temp_y, temp_x;
  574.  
  575.   getyx(curscr, temp_y, temp_x);
  576.   if (window_num == MESG_WINDOW) {
  577.     scroll_mesg();
  578.     mvwaddstr(mesg_window, mesg_bottom, 0, msg);
  579.     wclrtoeol(mesg_window);
  580.   }
  581.   else {
  582.     werase(*window_ptr[window_num]);
  583.     mvwaddstr(*window_ptr[window_num], 0, 0, msg);
  584.   }
  585.   ovl_refresh(window_num);
  586.   move(temp_y, temp_x);
  587.   refresh();
  588. }
  589.  
  590. game_is_over()
  591. {
  592.   if (!show_play)
  593.     toggle_mesg();
  594.   werase(round_window);
  595.   wrefresh(round_window);
  596.   werase(lead_window);
  597.   wstandout(lead_window);
  598.   mvwaddstr(lead_window, 0, 0, "--More--");
  599.   wstandend(lead_window);
  600.   wrefresh(lead_window);
  601.   (void) get_char();
  602. }
  603.  
  604. start_game()
  605. {
  606.   werase(play_window);
  607.   mvwaddstr(header_window, 0, 1, "player  score  total");
  608.   show_play = show_old = FALSE;
  609.   toggle_mesg();            /* Show play and score windows */
  610. }
  611.  
  612. /*
  613.  * Scan input for redraw screen requests or ':' messages.
  614.  * Also scan socket for incoming commands.
  615.  */
  616. scan()
  617. {
  618.     int        i, temp_y, temp_x;
  619.     char        buf[64];
  620.     fd_type    read_fd;
  621.     int        nready;
  622.     extern int    errno;
  623.  
  624.     int     mikey;
  625.         char    remember[57];
  626.  
  627.     fd_init(dealer_socket, &read_fd);
  628.     if (!got_char)
  629.         fd_set(0, &read_fd);
  630.     do {
  631.         nready = select(WIDTH, &read_fd, (fd_type *) 0, (fd_type *) 0,
  632.         (struct timeval *) 0);
  633.     }
  634.     while (nready == -1 && errno == EINTR);
  635.     if (nready == 0)
  636.         return;
  637.     if (fd_isset(0, read_fd)) {
  638.         got_char = get_char();
  639.         getyx(curscr, temp_y, temp_x);
  640.         switch (got_char) {
  641.         case '\f' :
  642.             wrefresh(curscr);    /* Redraw screen */
  643.             got_char = FALSE;
  644.             break;
  645.  
  646.         case ' '  :
  647.         case '\t' :
  648.         case '\n' :
  649.         case '\r' :
  650.             got_char = FALSE;    /* Ignore white space */
  651.             break;
  652.  
  653.         case 'M' :
  654.         case 'm' :
  655.             toggle_mesg();
  656.             got_char = FALSE;
  657.             break;
  658.  
  659.         case 'L' :
  660.         case 'l' :
  661.               if (show_play) {
  662.               mikey_old(TRUE);
  663.             }
  664.             got_char = FALSE;
  665.             break;
  666.  
  667.         case ':' :
  668.                   for (mikey = 0; mikey < 56; mikey++) {
  669.               wmove(mesg_window, 0, mikey);
  670.               remember[mikey] = winch(mesg_window);
  671.             }
  672. /*
  673.   scroll_mesg();       
  674. */
  675.             /* Message to all players */
  676.  
  677.             mvwaddstr(mesg_window, mesg_bottom, 0, "message: ");
  678.             wmove(mesg_window, mesg_bottom, 9);
  679.             wclrtoeol(mesg_window);
  680.             wrefresh(mesg_window);
  681.             buf[0] = 'M';
  682.             for (i = 1; (i < 48) && ((buf[i] = get_char()) != '\n') && buf[i] != '\r';
  683.                     i++) {
  684. #ifndef SYSV
  685.                 if (buf[i] == _tty.sg_erase) {
  686. #else
  687.                 if (buf[i] == CERASE) {
  688. #endif
  689.                     i -= 2;
  690.                     if (i < 0)
  691.                         i = 0;
  692.                     else {
  693.                         wmove(mesg_window, mesg_bottom, i+9);
  694.                         wdelch(mesg_window);
  695.                     }
  696.                 } 
  697.                 else {
  698. #ifndef SYSV
  699.                     if (buf[i] == _tty.sg_kill) {
  700. #else
  701.                     if (buf[i] == CKILL) {
  702. #endif
  703.                         wmove(mesg_window, mesg_bottom, 9);
  704.                         wclrtoeol(mesg_window);
  705.                         i = 0;
  706.                     } 
  707.                     else
  708.                       if (buf[i] <= 27) {
  709.                         i -= 1;
  710.                         if (i < 0)
  711.                           i = 0;
  712.                         else {
  713.                           wmove(mesg_window, mesg_bottom, i+9);
  714.                           wdelch(mesg_window);
  715.                         }
  716.                       }
  717.                       else
  718.                         mvwaddch(mesg_window, mesg_bottom, i + 8, buf[i]);
  719.                 }
  720.                 wrefresh(mesg_window);
  721.             }
  722.  
  723.             wmove(mesg_window, 0, 0);
  724.                   for (mikey = 0; mikey < 56; mikey++) {
  725.               waddch(mesg_window, remember[mikey]);
  726.             }
  727.  
  728.             buf[i] = '\0';
  729.             send_message(buf+1);
  730.             got_char = FALSE;
  731.             break;
  732.  
  733.         case '~' :
  734.                 toggle_private_messages();
  735.             break;
  736.  
  737.         case ';' :
  738.                   for (mikey = 0; mikey < 56; mikey++) {
  739.               wmove(mesg_window, 0, mikey);
  740.               remember[mikey] = winch(mesg_window);
  741.             }
  742. /*
  743.   scroll_mesg();       
  744. */
  745.             /* Private message */
  746.  
  747.             mvwaddstr(mesg_window, mesg_bottom, 0, "player; ");
  748.             wmove(mesg_window, mesg_bottom, 8);
  749.             wclrtoeol(mesg_window);
  750.             wrefresh(mesg_window);
  751.             buf[0] = ';';
  752.             buf[1] = get_char();
  753.             mvwaddstr(mesg_window, mesg_bottom, 0, "message; ");
  754.             wmove(mesg_window, mesg_bottom, 9);
  755.             wclrtoeol(mesg_window);
  756.             wrefresh(mesg_window);
  757.             for (i = 2; (i < 49) && ((buf[i] = get_char()) != '\n') && buf[i] != '\r';
  758.                     i++) {
  759. #ifndef SYSV
  760.                 if (buf[i] == _tty.sg_erase) {
  761. #else
  762.                 if (buf[i] == CERASE) {
  763. #endif
  764.                     i -= 2;
  765.                     if (i < 0)
  766.                         i = 0;
  767.                     else {
  768.                         wmove(mesg_window, mesg_bottom, i+8);
  769.                         wdelch(mesg_window);
  770.                     }
  771.                 } 
  772.                 else {
  773. #ifndef SYSV
  774.                     if (buf[i] == _tty.sg_kill) {
  775. #else
  776.                     if (buf[i] == CKILL) {
  777. #endif
  778.                         wmove(mesg_window, mesg_bottom, 8);
  779.                         wclrtoeol(mesg_window);
  780.                         i = 0;
  781.                     } 
  782.                     else
  783.                       if (buf[i] <= 27) {
  784.                         i -= 1;
  785.                         if (i < 0)
  786.                           i = 0;
  787.                         else {
  788.                           wmove(mesg_window, mesg_bottom, i+8);
  789.                           wdelch(mesg_window);
  790.                         }
  791.                       }
  792.                       else
  793.                         mvwaddch(mesg_window, mesg_bottom, i + 7, buf[i]);
  794.                 }
  795.                 wrefresh(mesg_window);
  796.             }
  797.  
  798.             wmove(mesg_window, 0, 0);
  799.                   for (mikey = 0; mikey < 56; mikey++) {
  800.               waddch(mesg_window, remember[mikey]);
  801.             }
  802.  
  803.             buf[i] = '\0';
  804.             send_private_message((int) buf[1]-'0', buf+2);
  805.             got_char = FALSE;
  806.         }
  807.         move(temp_y, temp_x);
  808.         refresh();
  809.     }
  810.     if (fd_isset(dealer_socket, read_fd)) {
  811.       do_socket();
  812.     }
  813. }
  814.  
  815. terminate()
  816. {
  817.     clear();
  818.     refresh();
  819.     (void) fflush(stdout);
  820.     endwin();
  821. }
  822.  
  823. /*
  824.  * show_table - display table which is position table_pos on screen.
  825.  */
  826. show_table(cur_ptr, table_pos)
  827. table_ptr    cur_ptr;
  828. int        table_pos;
  829. {
  830.     int    window_num, window_pos;
  831.     int     i;
  832.  
  833.     window_num = table_pos % 4 + 1;
  834.     window_pos =  (table_pos + 4) & 8;
  835.     for (i = 0; i < 6; i++) {
  836.         wmove(card_window[window_num], window_pos + i, 0);
  837.         wclrtoeol(card_window[window_num]);
  838.     }
  839.     mvwprintw(card_window[window_num], window_pos++, 0,
  840.         "     Table %d", table_pos + 1);
  841.     if (cur_ptr->closed)
  842.         mvwaddstr(card_window[window_num], window_pos++, 0,
  843.             "    <game over>");
  844.     else {
  845.         if (cur_ptr->hand == 0)
  846.             mvwaddstr(card_window[window_num], window_pos++, 0,
  847.                 "     <starting>");
  848.         else
  849.             mvwprintw(card_window[window_num], window_pos++, 0,
  850.                     "Hand: %d  Round: %d",
  851.                     cur_ptr->hand, cur_ptr->round);
  852.         for (i = 0; i <4; i++)
  853.             mvwaddstr(card_window[window_num], window_pos++, 5,
  854.                 cur_ptr->player_name[i]);
  855.     }
  856.     wrefresh(card_window[window_num]);
  857. }
  858.  
  859. /*
  860.  * show_tables - display up to 8 tables starting with table # start_id.
  861.  */
  862. show_tables(start_id)
  863. int    start_id;
  864. {
  865.     table_ptr    cur_ptr;
  866.     int        cur_id, i;
  867.  
  868.     for (i = 0; i < 8; i++)
  869.         screen_table_id[i] = 0;
  870.     werase(round_window);
  871.     if (table_count)
  872.         mvwprintw(round_window, 0, 0, "Page %d of %d",
  873.                 (start_id + 7) / 8, (table_count + 7) / 8);
  874.     wrefresh(round_window);
  875.     cur_ptr = first_table;
  876.     for (cur_id = 1; cur_id < start_id; cur_id++)
  877.         cur_ptr = cur_ptr->next_table;
  878.     for (cur_id = 0; (cur_id < 8) && cur_ptr;
  879.             cur_ptr = cur_ptr->next_table) {
  880.         screen_table_id[cur_id] = cur_ptr->table_id;
  881.         show_table(cur_ptr, cur_id++);
  882.     }
  883.     show_options();
  884. }
  885.  
  886. ask_option()
  887. {
  888.     werase(lead_window);
  889.     mvwaddstr(lead_window, 0, 0, "Option: ");
  890.     wrefresh(lead_window);
  891. }
  892.  
  893. show_options()
  894. {
  895.     werase(play_window);
  896.     mvwaddstr(play_window, 0, 0, "Options are:");
  897.     if (!first_game)
  898.         mvwaddstr(play_window, 1, 0, "<A>nother game");
  899.     mvwaddstr(play_window, 2, 0, "<N>ew game");
  900.     if ((table_count) && (first_game))
  901.         mvwaddstr(play_window, 3, 0, "<J>oin game");
  902.     if (table_count > 8)
  903.         mvwaddstr(play_window, 4, 0, "<M>ore games");
  904.     mvwaddstr(play_window, 5, 0, "<Q>uit");
  905.     wrefresh(play_window);
  906.     ask_option();
  907. }
  908.  
  909. option_scan(another)
  910. char *another;
  911. {
  912.   fd_type read_fd;
  913.   int i;
  914.   char ch;
  915.  
  916.   *another = FALSE;
  917.   fd_init(0, &read_fd);        /* stdin */
  918.   fd_set(dist_socket, &read_fd);
  919.   if (select(WIDTH, &read_fd, (fd_type *) 0, (fd_type *) 0,
  920.          (struct timeval *) 0) == -1)
  921.     if (select(WIDTH, &read_fd, (fd_type *) 0, (fd_type *) 0,
  922.            (struct timeval *) 0) == -1)
  923.       dist_died(2);
  924.   if (fd_isset(dist_socket, read_fd)) {
  925.     do_dist();
  926.   }
  927.   if (fd_isset(0, read_fd)) {
  928.     ch = get_char();
  929.     werase(text_window);
  930.     wrefresh(text_window);
  931.     switch (ch) {
  932.     case 'Q' :
  933.     case 'q' :
  934.       wimp_out();
  935.     case 'A' :
  936.     case 'a' :
  937.       *another = TRUE;
  938.       if (!first_game)
  939.     joined = TRUE;
  940.       break;
  941.     case 'N' :
  942.     case 'n' :
  943.       start_new_game();
  944.       joined = TRUE;
  945.       break;
  946.     case 'J' :
  947.     case 'j' :
  948.       if ((table_count) && (first_game)) {
  949.     mvwaddstr(lead_window, 0, 0, "Join table #:");
  950.     wrefresh(lead_window);
  951.     joining = TRUE;
  952.       }
  953.       break;
  954.     case 'M' :
  955.     case 'm' :
  956.       if (table_count > 8) {
  957.     if ((cur_screen_table += 8) > table_count)
  958.       cur_screen_table = 1;
  959.     for (i = CLUBS; i <= SPADES; i++) {
  960.       werase(card_window[i]);
  961.       wrefresh(card_window[i]);
  962.     }
  963.     show_tables(cur_screen_table);
  964.       }
  965.       break;
  966.     default:
  967.       if (joining && (ch >= '1') && (ch <= '8')) {
  968.     if (i = screen_table_id[ch - '1']) {
  969.       join_game(i);
  970.       joined = TRUE;
  971.     }
  972.     else {
  973.       mvwaddstr(text_window, 0, 0, "Table not open.");
  974.       wrefresh(text_window);
  975.       ask_option();
  976.     }
  977.       }
  978.       else {
  979.     mvwaddstr(text_window, 0, 0, "Huh?");
  980.     wrefresh(text_window);
  981.     ask_option();
  982.       }
  983.       joining = FALSE;
  984.       break;
  985.     }
  986.   }
  987. }
  988.  
  989. option_init()
  990. {
  991.   clear();
  992.   refresh();
  993. }
  994.  
  995. init_socket()
  996. {
  997. }
  998.  
  999. close_socket(s)
  1000. int s;
  1001. {
  1002. }
  1003.  
  1004. option_clear()
  1005. {
  1006. }
  1007.